/*
 * Logica.java
 *
 * Created on September 1, 2007, 3:30 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
package wasolicitudesfiec.logicacontrol;
  // <editor-fold defaultstate="collapsed" desc="import"> 
import entidad.*;
import entidad.ayudantias.Ayudantiavaria;
import entidad.ayudantias.Solicitudayudantia;

import entidad.ayudantias.Solicitudserayudante;
import entidad.ayudantias.TipoAyudantia;
import entidad.ayudantias.TipoAyudantia.TipoAyudantiaEnum;
import entidad.cambioCarrera.Solicitudcambiocarrera;
import hero.client.test.SimpleCallbackHandler;
import hero.interfaces.*;
import hero.util.HeroException;
import java.rmi.RemoteException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.*;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.CreateException;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
import javax.servlet.http.HttpSession;
import wasolicitudesfiec.xsl.pdf.Transformador;
import wasolicitudesfiec.SessionBean1;
import wasolicitudesfiec.authentication.AuthenticationPhaseListener;
import wasolicitudesfiec.consultas.*;
import wasolicitudesfiec.consultas.ayudantias.*;
import wasolicitudesfiec.consultas.cambioCarrera.ConsultasSolicitudcambiocarrera;
// </editor-fold>
/**
 *
 * @author kabad
 */
public class Logica {

    ConexionDB conexionDB = new ConexionDB();
    private static String realPath;
    private ConsultasSolicitudayudantia consultasSolicitudayudantia = new ConsultasSolicitudayudantia();
    private ConsultasSolicitudserayudante consultasSolicitudserayudante = new ConsultasSolicitudserayudante();
    private ConsultasSolicitudcambiocarrera consultasSolicitudcambiocarrera = new ConsultasSolicitudcambiocarrera();
    private ConsultasAyudantiavaria consultasAyudantiavaria = new ConsultasAyudantiavaria();
    private ConsultasMateria consultasMateria = new ConsultasMateria();
    private ConsultasProfesor consultasProfesor = new ConsultasProfesor();
    private ConsultasPersona consultasPersona = new ConsultasPersona();
    private ConsultasEstudiante consultasEstudiante = new ConsultasEstudiante();
    private ConsultasDatosacademicos consultasDatosacademicos = new ConsultasDatosacademicos();
    private ConsultasDatosfinancieros consultasDatosfinancieros = new ConsultasDatosfinancieros();
    private ConsultasDatosmateria consultasDatosmateria = new ConsultasDatosmateria();
    private ConsultasParametro consultasParametro = new ConsultasParametro();
    private ConsultasCategoria consultasCategoria = new ConsultasCategoria();
    private ConsultasCarrera consultasCarrera = new ConsultasCarrera();
    private ConsultasRol consultasRol = new ConsultasRol();
    private ConsultasPersonarol consultasPersonarol = new ConsultasPersonarol();
    private ConsultasEspecializacion consultasEspecializacion = new ConsultasEspecializacion();
    private ConsultasProfesorcarrera consultasProfesorcarrera = new ConsultasProfesorcarrera();
    private LogAyudantia logAyudantia = null;
    private LogCambioCarrera logCambioCarrera = null;
    public static final String modelo_SolicitarAyudantes = "Solicitar Ayudantes";
    public static final String modelo_SolicitarSerAyudante = "Solicitar Ser Ayudante";
    public static final String modelo_SolicitarCambioCarrera = "Solicitar Cambio de Carrera o Especializacion";
    public static final String version_SolicitarAyudantes = "2.0";
    public static final String version_SolicitarSerAyudante = "2.0";
    public static final String version_SolicitarCambioCarrera = "1.0";

    /** Creates a new instance of Logica */
    public Logica() {
    }

    public LogAyudantia getLogAyudantia() {
        if (logAyudantia == null) {
            logAyudantia = new LogAyudantia();
        }
        return logAyudantia;
    }

    public LogCambioCarrera getLogCambioCarrera() {
        if (logCambioCarrera == null) {
            logCambioCarrera = new LogCambioCarrera();
        }
        return logCambioCarrera;
    }

    // <editor-fold defaultstate="collapsed" desc="Metodos de autenticacion"> 
    public boolean autentica(String strUsuario, char[] strContrasena) {
        SimpleCallbackHandler handler = new SimpleCallbackHandler(strUsuario, strContrasena);
        LoginContext lc;
        try {
            lc = new LoginContext("TestClient", handler);
            lc.login();
            System.out.println("strUsuario" + strUsuario);
            System.out.println("strContrasena" + strContrasena);
            ProjectSessionHome prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            UserRegistrationHome userRHome = (UserRegistrationHome) UserRegistrationUtil.getHome();
            UserSessionHome usrHome = (UserSessionHome) UserSessionUtil.getHome();

            ProjectSession prjSession = prjHome.create();
            UserRegistration usrReg = userRHome.create();
            UserSession usrSession = usrHome.create();

            return true;
        } catch (LoginException ex) {
            ex.printStackTrace();
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return false;

    }

    public boolean autentica(String strUsuario, char[] strContrasena, ExternalContext externalContext) {
        ProjectSessionHome prjHome;
        // User Adminauthentication
        if (strUsuario == null) {
            strUsuario = "lbeltran";
        }
        if (strContrasena == null) {
            strContrasena = new char[3];
            strContrasena[0] = '1';
            strContrasena[1] = '2';
            strContrasena[2] = '3';
        }

        System.out.println("java.security.auth.login.config: " + System.getProperty("java.security.auth.login.config"));
        System.out.println("java.naming.factory.initial: " + System.getProperty("java.naming.factory.initial"));
        System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");//Linea agregada

        SimpleCallbackHandler handler = new SimpleCallbackHandler(strUsuario, strContrasena);
        LoginContext lc;
        try {
            lc = new LoginContext("TestClient", handler);
            lc.login();
            System.out.println("strUsuario" + strUsuario);
            System.out.println("strContrasena" + strContrasena);
            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            UserRegistrationHome userRHome = (UserRegistrationHome) UserRegistrationUtil.getHome();
            UserSessionHome usrHome = (UserSessionHome) UserSessionUtil.getHome();

            ProjectSession prjSession = prjHome.create();
            UserRegistration usrReg = userRHome.create();
            UserSession usrSession = usrHome.create();

            Usuario usuario = new Usuario();
            usuario.setPassword(strContrasena);
            usuario.setUsuario(strUsuario);

            externalContext.getSessionMap().put(AuthenticationPhaseListener.USER_SESSION_KEY, usuario);


            return true;
        } catch (LoginException ex) {
            ex.printStackTrace();
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return false;
    }

    public boolean autenticaComodin() {
        char[] passComodin = new char[7];
        passComodin[0] = 'c';
        passComodin[1] = 'o';
        passComodin[2] = 'm';
        passComodin[3] = 'o';
        passComodin[4] = 'd';
        passComodin[5] = 'i';
        passComodin[6] = 'n';
        return autentica("comodin", passComodin);
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de administracion de procesos, actividades y objetos de bonita"> 

    public UserRegistration getUserRegistration() {
        UserRegistrationHome userRHome;
        try {
            userRHome = (UserRegistrationHome) UserRegistrationUtil.getHome();
            UserRegistration urSession = userRHome.create();
            return urSession;
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public ProjectSession getProjectSession() {
        ProjectSessionHome prjHome;

        try {
            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            return prjSession;
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public UserSession getUserSession() {
        UserSession usrSession;
        UserSessionHome usrHome;

        try {
            usrHome = UserSessionUtil.getHome();
            usrSession = usrHome.create();

            return usrSession;
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public static void setRealPath(String realPath1) {
        realPath = realPath1;
    }

    public static String getRealPath() {
        return realPath;
    }

    public static String getRealPath_XML() {
        return realPath + "xml\\";
    }

    public Vector<BnProjectLightValue> leerProcesosAIniciarDelUsuario() {
        Collection listaBnProjectLightValue;
        UserSession usrSession;
        UserSessionHome usrHome;

        Vector<BnProjectLightValue> listaProcesos = new Vector<BnProjectLightValue>();
        try {
            usrHome = UserSessionUtil.getHome();
            usrSession = usrHome.create();
            listaBnProjectLightValue = usrSession.getModels();
            for (Object elem : listaBnProjectLightValue) {
                BnProjectLightValue pr = (BnProjectLightValue) elem;
                listaProcesos.add(pr);
            }
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return listaProcesos;
    }

    public String leerNombreDeLaPrimeraActividad(String nombreModelo, String version) {
        BnEdgeValue edge;
        BnNodeLightValue actividad;
        ProjectSessionHome prjHome;
        Collection listaModelos;
        UserSession usrSession;
        UserSessionHome usrHome;
        HashMap<String, BnNodeLightValue> actividades = new HashMap<String, BnNodeLightValue>();
        try {
            usrHome = UserSessionUtil.getHome();
            usrSession = usrHome.create();

            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();

            if (prjSession.existingProject(nombreModelo, version)) {
//                System.out.println("si existe el modelo: "+nombreModelo);
                prjSession.initModelWithVersion(nombreModelo, version);
//                System.out.println("prjSession.getName(): "+prjSession.getName());


                for (Object elem : prjSession.getNodesNames()) {
//                    System.out.println("Nodo: "+elem);
                    actividad = prjSession.getNodeLightValue((String) elem);
                    actividades.put((String) elem, actividad);

                }
                for (Object elem : prjSession.getEdgesNames()) {
                    edge = prjSession.getEdgeValue((String) elem);
//                    System.out.println("Edge: "+elem+" salida: "+edge.getOutBnNode().getName()+" actividad de llegada:"+edge.getInBnNode().getName());
                    actividades.remove(edge.getOutBnNode().getName());
                }
                if (actividades.size() > 0) {
//                    System.out.println("Si quedo una actividad:xx "+((BnNodeLightValue)actividades.values().toArray()[0]).getName());
                    return ((BnNodeLightValue) actividades.values().toArray()[0]).getName();
                }


            }


        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public ArrayList<BnNodeValue> leerActividadesPendientes(String nombreModelo, UserSession usrSession, ProjectSession prjSession) {
        BnNodeValue actividadTemp;
        ProjectSessionHome prjHome;
        Collection listaPorHacer;
        Collection instancias;
//	UserSession usrSession;
        UserSessionHome usrHome;
        ArrayList<BnNodeValue> listaActividadesPendientes = new ArrayList<BnNodeValue>();

        try {
            instancias = usrSession.getProjectListNames();

            for (Object elem : instancias) {
                prjSession.initProject((String) elem);
                if (prjSession.getProjectNameOfInstance((String) elem).equals(nombreModelo)) {
//                    System.out.println("parent: "+prjSession.getParent()+" getProjectNameOfInstance: "+prjSession.getProjectNameOfInstance((String) elem));
                    listaPorHacer = usrSession.getToDoList((String) elem);
                    for (Object elem2 : listaPorHacer) {
                        actividadTemp = prjSession.getNodeValue((String) elem2);
//                    System.out.println("Actividad: "+actividadTemp.getName()+" Proyecto:"+actividadTemp.getBnProject().getName());
                        listaActividadesPendientes.add(actividadTemp);
                    }
                }

            }
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        }
        return listaActividadesPendientes;
    }

    public ArrayList<String> leerModelosDeActividadesPendientes() {
        String nombreModelo;
        ArrayList<String> listaModelosPendientes = new ArrayList<String>();
        HashMap mapaModelosPendientes = new HashMap();
        Collection listaPorHacer;
        Collection instancias;
        ProjectSessionHome prjHome;
        UserSession usrSession;
        UserSessionHome usrHome;
        try {
            usrHome = UserSessionUtil.getHome();
            usrSession = usrHome.create();

            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();

            instancias = usrSession.getProjectListNames();

            for (Object elem : instancias) {
                prjSession.initProject((String) elem);
//                    System.out.println("parent: "+prjSession.getParent()+" getProjectNameOfInstance: "+prjSession.getProjectNameOfInstance((String) elem));
                listaPorHacer = usrSession.getToDoList((String) elem);
                if (listaPorHacer != null && listaPorHacer.size() > 0) {
                    nombreModelo = prjSession.getProjectNameOfInstance((String) elem);
//                    listaModelosPendientes.add(prjSession.getProjectNameOfInstance((String) elem));
                    if (mapaModelosPendientes.get(nombreModelo) == null) {
                        mapaModelosPendientes.put(nombreModelo, nombreModelo);
                        listaModelosPendientes.add(nombreModelo);
                    }
                }
            }
        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        }
        return listaModelosPendientes;
    }

    public String getProjectNameOfInstance(String instanceNombre) {
        String modelo = null;
        ProjectSessionHome prjHome;
        try {
            prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            modelo = prjSession.getProjectNameOfInstance(instanceNombre);

        } catch (RemoteException ex) {
            ex.printStackTrace();
        } catch (CreateException ex) {
            ex.printStackTrace();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (HeroException ex) {
            ex.printStackTrace();
        }
        return modelo;
    }

    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas de ayudantias y materias"> 
    //Convierte una materia a una logAyudantia para poder ser agregada luego en la lista de ayudantias
    public Ayudantiavaria materiaToAyudantia(Materia materia) {
        Ayudantiavaria tempAyudantia;
        tempAyudantia = new Ayudantiavaria();
        tempAyudantia.setIdAyudantiaVaria(materia.getIdMateria());
        tempAyudantia.setNombre(materia.getNombre());
        tempAyudantia.setDescripcion(materia.getCodigo());
        return tempAyudantia;
    }
    // Retorna un vetor con las ayudantias dependiendo del tipo 
    // tipo 0 -> Ayudantias academicas
    // tipo 1 -> Ayudantias Actividades Varias

    public Vector<Ayudantiavaria> leerAyudantias(TipoAyudantiaEnum tipoAyudantia) throws SQLException {
        Vector<Materia> listaMaterias;
        Vector<Ayudantiavaria> listaAyudantias;
        if (tipoAyudantia == TipoAyudantiaEnum.ACADEMICA) {//Ayudantías Académicas

            Ayudantiavaria tempAyudantia;
            listaAyudantias = new Vector<Ayudantiavaria>();
            listaMaterias = leerTodasLasMaterias();
            for (Materia elemMateria : listaMaterias) {
                tempAyudantia = materiaToAyudantia(elemMateria); //convierte una materia en logAyudantia

                listaAyudantias.add(tempAyudantia);
            }
        } else {//Ayudantías Varias

            listaAyudantias = leerTodasLasAyudantiasVarias();
        }
        return listaAyudantias;
    }

    public Vector<Materia> leerTodasLasMaterias() throws SQLException {
        Vector<Materia> listaMaterias = new Vector<Materia>();
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasMateria.setConexion(con);
            listaMaterias = consultasMateria.leerVariosMateria();
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaMaterias;
    }

    public Vector<Ayudantiavaria> leerTodasLasAyudantiasVarias() throws SQLException {
        Vector<Ayudantiavaria> listaAyudantias = new Vector<Ayudantiavaria>();
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasAyudantiavaria.setConexion(con);
            listaAyudantias = consultasAyudantiavaria.leerVariosAyudantiavaria();
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaAyudantias;
    }

    public TipoAyudantia leerTipoAyudantia(Solicitudayudantia solicitud) {
        TipoAyudantia tipoAyudantia = new TipoAyudantia();
        if (solicitud.getFkIdMateria() != 0) {
            tipoAyudantia.setTipo(TipoAyudantia.TipoAyudantiaEnum.ACADEMICA);
            tipoAyudantia.setNombre("Académica");
        } else {
            tipoAyudantia.setTipo(TipoAyudantia.TipoAyudantiaEnum.ACTIVIDADES_VARIAS);
            tipoAyudantia.setNombre("Actividades Varias");
        }
        return tipoAyudantia;
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas Carrera, Especializacion"> 

    public Vector<Parametro> leerCarreras() throws SQLException {
        Vector<Parametro> listaCarreras = new Vector<Parametro>();
        Connection con = null;
        int idCategoria = 1;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);
            listaCarreras = consultasParametro.leerVariosParametroPorIdCategoria(idCategoria);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaCarreras;
    }

    public Vector<Parametro> leerVariosParametroPorIdfkParent(int idParametro) throws SQLException {
        Vector<Parametro> listaEspecializacion = new Vector<Parametro>();
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);

            listaEspecializacion = consultasParametro.leerVariosParametroPorIdfkParent(idParametro);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaEspecializacion;
    }

    public Parametro leerParametro(int idParametro) throws SQLException {
        Parametro parametro;
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasParametro.setConexion(con);

            parametro = consultasParametro.leerParametro(idParametro);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return parametro;
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas Persona"> 

    public Vector<Persona> leerPersonaPorRol(String nombreRol) {
        Connection con = null;
        Vector<Persona> personas = new Vector<Persona>();
        Vector<Personarol> personasRol = new Vector<Personarol>();
        Rol rol;
        try {
            con = conexionDB.openConexion();
            consultasPersona.setConexion(con);
            consultasPersonarol.setConexion(con);
            consultasRol.setConexion(con);
            rol = consultasRol.leerRolPorNombre(nombreRol, -1);
            personasRol = consultasPersonarol.leerVariosPersonarolPorIdRol(rol.getIdRol());
            for (Personarol personarol : personasRol) {
                personas.add(consultasPersona.leerPersona(personarol.getFkIdPersona()));
            }
        } catch (SQLException ex) {
            Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return personas;
    }

    public Persona leerPersonaPorUsuario(String usuario) throws SQLException {
        Persona persona = null;
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            consultasPersona.setConexion(con);
            persona = consultasPersona.leerPersonaPorUsuario(usuario, -1);

        } finally {
            try {
                con.close();
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return persona;
    }

    public Profesor leerProfesorPorUsuario(String usuario) throws SQLException {
        Connection con = null;
        Profesor profesor = null;
        try {
            con = conexionDB.openConexion();
            consultasProfesor.setConexion(con);
            profesor = consultasProfesor.leerProfesorPorUsuario(-1, usuario);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return profesor;
    }

    public Estudiante leerEstudiantePorUsuario(String usuario) throws SQLException {
        Connection con = null;
        Estudiante estudiante = null;
        try {
            con = conexionDB.openConexion();
            consultasEstudiante.setConexion(con);
            consultasPersona.setConexion(con);
            estudiante = consultasEstudiante.leerEstudiantePorUsuario(-1, usuario);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return estudiante;
    }

    public Profesor leerProfesorPorCarrera(int idCarrera) throws SQLException {
        Connection con = null;
        Profesor profesor = null;
        Profesorcarrera profesorcarrera = new Profesorcarrera();
        try {
            con = conexionDB.openConexion();
            consultasProfesorcarrera.setConexion(con);
            consultasProfesor.setConexion(con);
            consultasPersona.setConexion(con);
            profesorcarrera = consultasProfesorcarrera.leerProfesorcarreraPorIdCarrera(idCarrera);
            profesor = consultasProfesor.leerProfesor(profesorcarrera.getFkIdProfesor());
            Persona persona = consultasPersona.leerPersona(profesor.getIdProfesor());
            profesor.setPersona(persona);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return profesor;
    }

// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="Metodos de consultas DatosFinancieros"> 
    public Datosfinancieros nuevoDatosFinancieros(Datosfinancieros datosfinancieros) throws SQLException, Exception {
        Connection con = null;
        Datosfinancieros nuevosDatosFinancieros = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasDatosfinancieros.setConexion(con);
            nuevosDatosFinancieros = consultasDatosfinancieros.HLnuevoDatosfinancieros(datosfinancieros);
            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return nuevosDatosFinancieros;
    }

    public void guardarDatosFinancieros(Datosfinancieros datosfinancieros) throws SQLException, Exception {
        Connection con = null;
        try {
            con = conexionDB.openConexion();
            con.setAutoCommit(false);
            consultasDatosfinancieros.setConexion(con);
            consultasDatosfinancieros.HLmodificarDatosfinancieros(datosfinancieros);
            con.commit();
        } catch (Exception ex) {
            if (con != null) {
                con.rollback();
            }
            throw ex;
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    // </editor-fold>
    // <editor-fold defaultstate="collapsed" desc="Metodos de genercion de contrato y manejo xml"> 
    

   

    // </editor-fold> 
    // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudCambioCarreraoEspecializacion">
    public class LogCambioCarrera {

        public LogCambioCarrera() {
        }

        public Solicitudcambiocarrera nuevoSolicitudCambio(Solicitudcambiocarrera solicitudcambio) throws SQLException, Exception {
            Connection con = null;
            Solicitudcambiocarrera nuevaSolicitudcambio = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudcambiocarrera.setConexion(con);
                nuevaSolicitudcambio = consultasSolicitudcambiocarrera.HLnuevoSolicitudcambiocarrera(solicitudcambio);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudcambio;
        }

        public Solicitudcambiocarrera clonarSolicitudAyudantia(Solicitudcambiocarrera solicitudcambio) throws SQLException, Exception {
            Connection con = null;
            Solicitudcambiocarrera cloneSolicitudcambio = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudcambiocarrera.setConexion(con);
                int fkParent = solicitudcambio.getFkParent();
                solicitudcambio.setFkParent(solicitudcambio.getIdSolicitudCambioCarrera());
                cloneSolicitudcambio = consultasSolicitudcambiocarrera.HLnuevoSolicitudcambiocarrera(solicitudcambio);
                solicitudcambio.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudcambio;
        }

        public Solicitudcambiocarrera leerSolicitudCambio(int idSolicitud) throws SQLException {
            Connection con = null;
            Solicitudcambiocarrera solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudcambiocarrera.setConexion(con);
                solicitud = consultasSolicitudcambiocarrera.leerSolicitudcambiocarrera(idSolicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;

        }

        public Solicitudcambiocarrera leerSolicitudCambioNivel2(int idSolicitud) throws SQLException {
            Solicitudcambiocarrera solicitud = null;
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudcambiocarrera.setConexion(con);
                consultasParametro.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);
                consultasEstudiante.setConexion(con);
                solicitud = consultasSolicitudcambiocarrera.leerSolicitudcambiocarrera(idSolicitud);
                solicitud = leerSolicitudCambioNivel2(solicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        private Solicitudcambiocarrera leerSolicitudCambioNivel2(Solicitudcambiocarrera solicitud) throws SQLException {
            String temp;
            if (solicitud.getFkIdCarreraActual() != 0) {
                Parametro carreraActual;
                carreraActual = consultasParametro.leerParametro(solicitud.getFkIdCarreraActual());
                if (carreraActual.getFkIdParent() != 0) {
                    temp = consultasParametro.leerParametro(carreraActual.getFkIdParent()).getNombre();
                    temp += " especialización " + carreraActual.getNombre();
                    carreraActual.setNombre(temp);
                }
                solicitud.setCarreraActual(carreraActual);
            }
            if (solicitud.getFkIdCarreraNueva() != 0) {
                Parametro carreraNueva;
                carreraNueva = consultasParametro.leerParametro(solicitud.getFkIdCarreraNueva());
                if (carreraNueva.getFkIdParent() != 0) {
                    temp = consultasParametro.leerParametro(carreraNueva.getFkIdParent()).getNombre();
                    temp += " especialización " + carreraNueva.getNombre();
                    carreraNueva.setNombre(temp);
                }
                solicitud.setCarreraNueva(carreraNueva);
            }
            Estudiante estudiante;
            Persona personaEstudiate;
            estudiante = consultasEstudiante.leerEstudiante(solicitud.getFkidestudiante());
            personaEstudiate = consultasPersona.leerPersona(estudiante.getIdEstudiante());
            estudiante.setPersona(personaEstudiate);
            solicitud.setEstudiante(estudiante);
            Profesor profesor;
            Persona personaProfesor, personaSubdecano;
            if (solicitud.getFkIdProfesor() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdProfesor());
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
                solicitud.setProfesor(profesor);
            }
            if (solicitud.getFkIdSubDecano() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdSubDecano());
                personaSubdecano = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaSubdecano);
                solicitud.setSubDecano(profesor);
            }
            return solicitud;
        }

        public Solicitudcambiocarrera guardarYClonarSolicitudCambio(Solicitudcambiocarrera solicitud) throws SQLException, Exception {
            Connection con = null;
            Solicitudcambiocarrera cloneSolicitudCambio = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudcambiocarrera.setConexion(con);
                consultasSolicitudcambiocarrera.HLmodificarSolicitudcambiocarrera(solicitud);
                int fkParent = solicitud.getFkParent();
                solicitud.setFkParent(solicitud.getIdSolicitudCambioCarrera());
                cloneSolicitudCambio = consultasSolicitudcambiocarrera.HLnuevoSolicitudcambiocarrera(solicitud);
                solicitud.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudCambio;
        }
    }
    // </editor-fold >

    public class LogAyudantia {

        public LogAyudantia() {
        }
        //falta enviar correos notificando que se 

        public void cancelarProcesosSolicitarSerAyudante(Solicitudayudantia solicitudayudantia) throws NamingException, CreateException, RemoteException, HeroException, Exception {

            Vector<Solicitudserayudante> listaSolicitudSerAyudante = solicitudayudantia.getListaSolicitudserayudante();
            ProjectSessionHome prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            UserSessionHome usrHome = (UserSessionHome) UserSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            UserSession usrSession = usrHome.create();
            String nombreActividadAprob = "Aprobacion de Solicitud"; //no seleccionados

            String nombreActividadContrat = "Contratacion del Estudiante";
            String nombreActividadProrroga = "Dar Prorroga"; //no contestaron

            BnNodeValue actividad;
            Solicitudserayudante solicitudserayudante;
            String nombreActividad = "";
             Date fecha = new Date();
            for (Solicitudserayudante object : listaSolicitudSerAyudante) {

                String nombreInstanciaProceso = object.getNombreinstanciaproceso();
                prjSession.initProject(nombreInstanciaProceso);
                if (object.getSeleccionado()) {
                    if (object.getRespuestaConfirmacion().equals("Rechazo")) {
                        //las instancias de los que rechazaron ya terminaron
                        continue;
                    }
                    if (object.getRespuestaConfirmacion().equals("Acepto")) {
                        nombreActividad = nombreActividadContrat;
                    }
                    if (object.getRespuestaConfirmacion().equals("NoContestado")) {
                        nombreActividad = nombreActividadProrroga;
                    }
                } else {
                    nombreActividad = nombreActividadAprob;
                }
                actividad = usrSession.getNode(nombreInstanciaProceso, nombreActividad);
                if (!(actividad != null && (actividad.getState() == hero.interfaces.Constants.Nd.READY || actividad.getState() == hero.interfaces.Constants.Nd.ANTICIPABLE))) {
                    throw new Exception();
                }
              
                object.setFechamodificacion(new java.sql.Date(fecha.getTime()));
                object.setEstado("Cancelada");
                solicitudserayudante = guardarYClonarSolicitudserayudante(object);                
                prjSession.setNodeProperty(nombreActividad, "idSolicitudActividad", solicitudserayudante.getIdSolicitudSerAyudante() + "");
                prjSession.setNodeProperty(nombreActividad, "AyudantiaCancelada", "Si");
                usrSession.startActivity(nombreInstanciaProceso, nombreActividad);
                usrSession.terminateActivity(nombreInstanciaProceso, nombreActividad);

            }

        }

        public void terminarProcesosSolicitarSerAyudante(Solicitudayudantia solicitudayudantia, int idSolicitudActividad) throws NamingException, CreateException, RemoteException, HeroException, Exception {
            Vector<Solicitudserayudante> listaSolicitudSerAyudante = solicitudayudantia.getListaSolicitudserayudante();
            ProjectSessionHome prjHome = (ProjectSessionHome) ProjectSessionUtil.getHome();
            UserSessionHome usrHome = (UserSessionHome) UserSessionUtil.getHome();
            ProjectSession prjSession = prjHome.create();
            UserSession usrSession = usrHome.create();
            String nombreActividadAprob = "Aprobacion de Solicitud"; //no seleccionados

            String nombreActividadContrat = "Contratacion del Estudiante";
            String nombreActividadProrroga = "Dar Prorroga"; //no contestaron
              Date fecha = new Date();
            BnNodeValue actividad;
            Solicitudserayudante solicitudserayudante;
            String nombreActividad = "";
            for (Solicitudserayudante object : listaSolicitudSerAyudante) {

                String nombreInstanciaProceso = object.getNombreinstanciaproceso();
                prjSession.initProject(nombreInstanciaProceso);
                if (object.getSeleccionado()) {
                    if (object.getRespuestaConfirmacion().equals("Rechazo")) {
                        //las instancias de los que rechazaron ya terminaron
                        continue;
                    }
                    if (object.getRespuestaConfirmacion().equals("Acepto")) {
                        nombreActividad = nombreActividadContrat;
                    }
                    if (object.getRespuestaConfirmacion().equals("NoConstestado")) {
                        nombreActividad = nombreActividadProrroga;
                    }
                } else {
                    nombreActividad = nombreActividadAprob;
                }//aqui se cayo

                actividad = usrSession.getNode(nombreInstanciaProceso, nombreActividad);
                if (!(actividad != null && (actividad.getState() == hero.interfaces.Constants.Nd.READY || actividad.getState() == hero.interfaces.Constants.Nd.ANTICIPABLE))) {
                    throw new Exception();
                }
                object.setFkIdSolicitudAyudantia(idSolicitudActividad);
                object.setFechamodificacion(new java.sql.Date(fecha.getTime()));
                object.setEstado("Terminada");
                
                solicitudserayudante = guardarYClonarSolicitudserayudante(object);
                prjSession.setNodeProperty(nombreActividad, "idSolicitudActividad", solicitudserayudante.getIdSolicitudSerAyudante() + "");
                usrSession.startActivity(nombreInstanciaProceso, nombreActividad);
                usrSession.terminateActivity(nombreInstanciaProceso, nombreActividad);
            }
        }

        // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudAyudantia"> 
        public Solicitudayudantia clonarSolicitudAyudantia(Solicitudayudantia solicitudayudantia) throws SQLException, Exception {
            Connection con = null;
            Solicitudayudantia cloneSolicitudayudantia = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudayudantia.setConexion(con);
                int fkParent = solicitudayudantia.getFkParent();
                solicitudayudantia.setFkParent(solicitudayudantia.getIdSolicitudAyudantia());
                cloneSolicitudayudantia = consultasSolicitudayudantia.HLnuevoSolicitudayudantia(solicitudayudantia);
                solicitudayudantia.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudayudantia;
        }

        public Solicitudayudantia nuevoSolicitudayudantia(Solicitudayudantia solicitudayudantia) throws SQLException, Exception {
            Connection con = null;
            Solicitudayudantia nuevaSolicitudayudantia = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudayudantia.setConexion(con);
                nuevaSolicitudayudantia = consultasSolicitudayudantia.HLnuevoSolicitudayudantia(solicitudayudantia);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudayudantia;
        }

        public Solicitudayudantia guardarYClonarSolicitudAyudantia(Solicitudayudantia solicitudayudantia) throws Exception {
            Connection con = null;
            Solicitudayudantia cloneSolicitudayudantia = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudayudantia.setConexion(con);
                consultasSolicitudayudantia.HLmodificarSolicitudayudantia(solicitudayudantia);
                int fkParent = solicitudayudantia.getFkParent();
                solicitudayudantia.setFkParent(solicitudayudantia.getIdSolicitudAyudantia());
                cloneSolicitudayudantia = consultasSolicitudayudantia.HLnuevoSolicitudayudantia(solicitudayudantia);
                solicitudayudantia.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudayudantia;
        }

        public void guardarSolicitudAyudantia(Solicitudayudantia solicitudayudantia) throws SQLException, Exception {
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudayudantia.setConexion(con);
                consultasSolicitudayudantia.HLmodificarSolicitudayudantia(solicitudayudantia);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }

        public Solicitudayudantia leerSolicitudayudantia(int idSolicitudAyudantia) throws SQLException {
            Connection con = null;
            Solicitudayudantia solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                solicitud = consultasSolicitudayudantia.leerSolicitudayudantia(idSolicitudAyudantia);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        public Solicitudayudantia leerSolicitudayudantiaNivel2(int idSolicitudAyudantia) throws SQLException {
            Solicitudayudantia solicitud = null;
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                consultasAyudantiavaria.setConexion(con);
                consultasMateria.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);
                solicitud = consultasSolicitudayudantia.leerSolicitudayudantia(idSolicitudAyudantia);
                solicitud = leerSolicitudayudantiaNivel2(solicitud);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        private Solicitudayudantia leerSolicitudayudantiaNivel2(Solicitudayudantia solicitud) throws SQLException {
            Ayudantiavaria ayudantiaVaria;
            if (solicitud.getFkIdAyudantiaVaria() != 0) {
                ayudantiaVaria = consultasAyudantiavaria.leerAyudantiavaria(solicitud.getFkIdAyudantiaVaria());
                solicitud.setAyudantiavaria(ayudantiaVaria);
            }
            Materia materia;
            if (solicitud.getFkIdMateria() != 0) {
                materia = consultasMateria.leerMateria(solicitud.getFkIdMateria());
                solicitud.setMateria(materia);
            }
            Profesor profesor;
            Persona personaProfesor;
            if (solicitud.getFkIdProfesor() != 0) {
                profesor = consultasProfesor.leerProfesor(solicitud.getFkIdProfesor());
                solicitud.setProfesor(profesor);
                personaProfesor = consultasPersona.leerPersona(profesor.getIdProfesor());
                profesor.setPersona(personaProfesor);
            }
            return solicitud;
        }

        public Solicitudayudantia leerSolicitudayudantiaNivel3(int idSolicitudAyudantia) throws SQLException {
            Connection con = null;
            Solicitudayudantia solicitud = null;
            Vector<Solicitudserayudante> listaSolicitudserayudante = new Vector<Solicitudserayudante>();
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                consultasSolicitudserayudante.setConexion(con);
                consultasEstudiante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasCarrera.setConexion(con);
                consultasDatosacademicos.setConexion(con);
                consultasDatosfinancieros.setConexion(con);
                consultasEspecializacion.setConexion(con);
                consultasAyudantiavaria.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasMateria.setConexion(con);
                consultasDatosmateria.setConexion(con);
                solicitud = consultasSolicitudayudantia.leerSolicitudayudantia(idSolicitudAyudantia);
                solicitud = leerSolicitudayudantiaNivel2(solicitud);
                listaSolicitudserayudante = consultasSolicitudserayudante.leerVariosSolicitudserayudantePorIdSolicitudAyudantia(idSolicitudAyudantia);
                solicitud.setListaSolicitudserayudante(listaSolicitudserayudante);
                for (Solicitudserayudante solicitudserayudante : listaSolicitudserayudante) {
                    solicitudserayudante.setSolicitudayudantia(solicitud);
                    leerSolicitudserayudanteNivel2(solicitudserayudante);
                }

            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        public Vector<Solicitudayudantia> leerSolicitudayudantiaDisponibles() throws SQLException {
            Connection con = null;
            Vector<Solicitudayudantia> listaSolicitud = new Vector<Solicitudayudantia>();
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);
                consultasAyudantiavaria.setConexion(con);
                consultasMateria.setConexion(con);
                consultasProfesor.setConexion(con);
                consultasPersona.setConexion(con);
                listaSolicitud = consultasSolicitudayudantia.leerSolicitudayudantiaDisponibles();
                for (Solicitudayudantia solicitudayudantia : listaSolicitud) {
                    leerSolicitudayudantiaNivel2(solicitudayudantia);
                }

            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return listaSolicitud;

        }

        public Solicitudayudantia existeSolicitudayudantiaPorIdAyudantia(int idAyudantiaVaria, int idMateria) throws SQLException {
            Connection con = null;
            Solicitudayudantia solicitudAyudantia = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudayudantia.setConexion(con);

                solicitudAyudantia = consultasSolicitudayudantia.leerSolicitudayudantiaPorIdAyudantia(idAyudantiaVaria, 1, idMateria);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitudAyudantia;
        }
        // </editor-fold >
        // <editor-fold defaultstate="collapsed" desc="Metodos de consultas SolicitudserAyudante">

        public Solicitudserayudante nuevoSolicitudserayudante(Solicitudserayudante solicitudserayudante) throws SQLException, Exception {
            Connection con = null;
            Solicitudserayudante nuevaSolicitudserayudante = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudserayudante.setConexion(con);
                nuevaSolicitudserayudante = consultasSolicitudserayudante.HLnuevoSolicitudserayudante(solicitudserayudante);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return nuevaSolicitudserayudante;

        }

        public Solicitudserayudante clonarSolicitudserayudante(Solicitudserayudante solicitudserayudante) throws Exception {
            Connection con = null;
            Solicitudserayudante cloneSolicitudserayudante = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudserayudante.setConexion(con);
                int fkParent = solicitudserayudante.getFkParent();
                solicitudserayudante.setFkParent(solicitudserayudante.getIdSolicitudSerAyudante());
                cloneSolicitudserayudante = consultasSolicitudserayudante.HLnuevoSolicitudserayudante(solicitudserayudante);
                solicitudserayudante.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudserayudante;
        }

        public void guardarSolicitudserayudante(Solicitudserayudante solicitudserayudante) throws SQLException, Exception {
            Connection con = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudserayudante.setConexion(con);
                consultasSolicitudserayudante.HLmodificarSolicitudserayudante(solicitudserayudante);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }

        public Solicitudserayudante guardarYClonarSolicitudserayudante(Solicitudserayudante solicitudserayudante) throws SQLException, Exception {
            Connection con = null;
            Solicitudserayudante cloneSolicitudserayudante = null;
            try {
                con = conexionDB.openConexion();
                con.setAutoCommit(false);
                consultasSolicitudserayudante.setConexion(con);
                consultasSolicitudserayudante.HLmodificarSolicitudserayudante(solicitudserayudante);
                int fkParent = solicitudserayudante.getFkParent();
                solicitudserayudante.setFkParent(solicitudserayudante.getIdSolicitudSerAyudante());
                cloneSolicitudserayudante = consultasSolicitudserayudante.HLnuevoSolicitudserayudante(solicitudserayudante);
                solicitudserayudante.setFkParent(fkParent);
                con.commit();
            } catch (Exception ex) {
                if (con != null) {
                    con.rollback();
                }
                throw ex;
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return cloneSolicitudserayudante;
        }

        public Solicitudserayudante leerSolicitudserayudante(int idSolicitudSerAyudante) throws SQLException {
            Connection con = null;
            Solicitudserayudante solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudserayudante.setConexion(con);
                solicitud = consultasSolicitudserayudante.leerSolicitudserayudante(idSolicitudSerAyudante);
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;
        }

        public Solicitudserayudante leerSolicitudserayudanteNivel2(int idSolicitudSerAyudante) throws SQLException {
            Connection con = null;
            Solicitudserayudante solicitud = null;
            Solicitudayudantia solicitudAyudantia = null;
            try {
                con = conexionDB.openConexion();

                consultasSolicitudserayudante.setConexion(con);
                solicitud = consultasSolicitudserayudante.leerSolicitudserayudante(idSolicitudSerAyudante);
                solicitudAyudantia = leerSolicitudayudantiaNivel2(solicitud.getFkIdSolicitudAyudantia());
                solicitud.setSolicitudayudantia(solicitudAyudantia);

            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitud;

        }

        public Solicitudserayudante leerSolicitudserayudanteNivel2(Solicitudserayudante solicitudserayudante) throws SQLException {
            Estudiante estudiante;
            Persona personaEstudiante;
            Connection con = null;
             Parametro carrera;
            try {
                con = conexionDB.openConexion();
                consultasEstudiante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasParametro.setConexion(con);
                consultasDatosacademicos.setConexion(con);
                consultasDatosfinancieros.setConexion(con);
                consultasEspecializacion.setConexion(con);
                consultasMateria.setConexion(con);
                consultasDatosmateria.setConexion(con);
                if (solicitudserayudante.getFkIdEstudiante() != 0) {
                    estudiante = consultasEstudiante.leerEstudiante(solicitudserayudante.getFkIdEstudiante());
                   
                    personaEstudiante = consultasPersona.leerPersona(estudiante.getIdEstudiante());
                    estudiante.setPersona(personaEstudiante);
                     solicitudserayudante.setEstudiante(estudiante);
                }               
                String temp;
                if (solicitudserayudante.getFkIdCarrera() != 0) {
                    carrera = consultasParametro.leerParametro(solicitudserayudante.getFkIdCarrera());
                if (carrera.getFkIdParent() != 0) {
                    temp = consultasParametro.leerParametro(carrera.getFkIdParent()).getNombre();
                    temp += " especialización " + carrera.getNombre();
                    carrera.setNombre(temp);
                }
                solicitudserayudante.setCarrera(carrera);
                }
                Datosacademicos datoAcademico;
                if (solicitudserayudante.getFkIdDatoAcademico() != 0) {
                    datoAcademico = consultasDatosacademicos.leerDatosacademicos(solicitudserayudante.getFkIdDatoAcademico());
                    solicitudserayudante.setDatosacademicos(datoAcademico);
                }
                Datosfinancieros datosFinancieros;
                if (solicitudserayudante.getFkIdDatosFinancieros() != 0) {
                    datosFinancieros = consultasDatosfinancieros.leerDatosfinancieros(solicitudserayudante.getFkIdDatosFinancieros());
                    solicitudserayudante.setDatosfinancieros(datosFinancieros);
                }
               Datosmateria datosmateria;
                if ((solicitudserayudante.getFkIdEstudiante() != 0) && solicitudserayudante.getSolicitudayudantia().getFkIdMateria() != 0) {
                    datosmateria = consultasDatosmateria.leerDatosmateria(solicitudserayudante.getFkIdEstudiante(), solicitudserayudante.getSolicitudayudantia().getFkIdMateria());
                    solicitudserayudante.setDatosmateria(datosmateria);
                }
            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return solicitudserayudante;
        }

        public boolean aplicoASolicitudAyudantia(String usuario, String nombreInstanciaProcesoProf) throws SQLException {
            Connection con = null;
            Solicitudserayudante solicitud = null;
            try {
                con = conexionDB.openConexion();
                consultasSolicitudserayudante.setConexion(con);
                consultasPersona.setConexion(con);
                consultasEstudiante.setConexion(con);
                solicitud = consultasSolicitudserayudante.leerSolicitudserayudantePorUsuarioPornombreInstancia(-1, usuario, nombreInstanciaProcesoProf);
                if (solicitud != null) {
                    return true;
                }

            } finally {
                try {
                    if (con != null) {
                        con.close();
                    }
                } catch (SQLException ex) {
                    Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return false;
        }
        // </editor-fold>
    }
// <editor-fold defaultstate="collapsed" desc="Metodos anteriores"> 
//     public String getNombreAyudantia(String nombreInstanciaProf, UserSession usrSession,ProjectSession prjSession) {
//        String nombreActividad = "Profesor Solicita Ayudantes";
//        BnNodeValue actividad;
//        BnNodePropertyValue property;
//        if (usrSession != null && prjSession != null) {
//            if (nombreInstanciaProf != null) {
//                try {
//                    prjSession.initProject(nombreInstanciaProf);
//                    actividad = usrSession.getNode(nombreInstanciaProf, nombreActividad);
//
//                    if (actividad != null) {
//                        property = prjSession.getNodeProperty(nombreActividad, "formulario");
//                        EnProfesorSolicitaAyudantes enProfesorSolicitaAyudantes = new EnProfesorSolicitaAyudantes();
//                        enProfesorSolicitaAyudantes.cargarXML(property.getTheValue());
//                        int tipoAyudantia = Integer.parseInt(enProfesorSolicitaAyudantes.getTipoAyudantia());
//                        int idAyudantia = Integer.parseInt(enProfesorSolicitaAyudantes.getNombreAyudantia());
//                        String nombre = leerAyudantia(tipoAyudantia, idAyudantia).getNombre();
//                        return nombre;
//                    }
//                } catch (SAXException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (IOException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (ParserConfigurationException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (HeroException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                }
//            }
//        }
//        return null;
//    }
//  public String getTipoAyudantia(String nombreInstanciaProf, UserSession usrSession,ProjectSession prjSession) {
//        String nombreActividad = "Profesor Solicita Ayudantes";
//        BnNodeValue actividad;
//        BnNodePropertyValue property;
//        if (usrSession != null && prjSession != null) {
//            if (nombreInstanciaProf != null) {
//                try {
//                    prjSession.initProject(nombreInstanciaProf);
//                    actividad = usrSession.getNode(nombreInstanciaProf, nombreActividad);
//
//                    if (actividad != null) {
//                        property = prjSession.getNodeProperty(nombreActividad, "formulario");
//                        EnProfesorSolicitaAyudantes enProfesorSolicitaAyudantes = new EnProfesorSolicitaAyudantes();
//                        enProfesorSolicitaAyudantes.cargarXML(property.getTheValue());
//                        int tipoAyudantia = Integer.parseInt(enProfesorSolicitaAyudantes.getTipoAyudantia());
//                        int idAyudantia = Integer.parseInt(enProfesorSolicitaAyudantes.getNombreAyudantia());
//                        String tipo = leerTipoAyudantia(tipoAyudantia);
//                       return tipo;
//                    }
//                } catch (SAXException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (IOException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (ParserConfigurationException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (HeroException ex) {
//                    Logger.getLogger(CTRL_ConfirmacionEstudiante.class.getName()).log(Level.SEVERE, null, ex);
//                }
//            }
//        }return null;
//    }
// </editor-fold >    
}
